/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package br.com.tbp.gui.financeiro;

import br.com.tbp.model.domain.financeiro.CondicaoConta;
import br.com.tbp.model.domain.financeiro.Conta;
import br.com.tbp.model.domain.financeiro.TipoConta;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.swing.table.AbstractTableModel;

/**
 *
 * @author Diego
 */
public class ContasTableModel extends AbstractTableModel {

    /* Lista de contas que representam as linhas da tabela*/
    private List<Conta> linhas;

    /* Array de Strings com o nome das colunas. */
    private String[] colunas = new String[]{
        "Baixada?", "ID conta", "Descrição", "Data", "Tipo", "Condição", "Valor R$"};


    /* Cria um ContasTableModel vazio. */
    public ContasTableModel() {
        this.linhas = new ArrayList<Conta>();
    }

    /* Cria um ContasTableModel carregado com
     * a lista de contas especificada. */
    public ContasTableModel(List<Conta> linhas) {
        this.linhas = linhas;
    }

    /* Retorna a quantidade de linhas. */
    public int getRowCount() {
        return linhas.size();
    }

    /* Retorna a quantidade de colunas. */
    @Override
    public int getColumnCount() {
        return colunas.length;
    }

    /* Retorna a classe dos elementos da coluna especificada.
     * Este método é usado pela JTable na hora de definir o editor da célula. */
    @Override
    public Class<?> getColumnClass(int columnIndex) {
        switch (columnIndex) {
            case 0:
                return Boolean.class;
            case 1:
                return Long.class;
            case 2:
                return String.class;
            case 3:
                return Date.class;
            case 4:
                return TipoConta.class;
            case 5:
                return CondicaoConta.class;
            case 6:
                return Double.class;
            default:
                throw new IndexOutOfBoundsException("columnIndex out of bounds");
        }
    }

    /* Retorna o nome da coluna no índice especificado.
     * Este método é usado pela JTable para saber o texto do cabeçalho. */
    @Override
    public String getColumnName(int columnIndex) {
        return colunas[columnIndex];
    }

    /* Retorna o valor da célula especificada
     * pelos índices da linha e da coluna. */
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        // Pega a conta da linha especificada.
        Conta conta = this.getConta(rowIndex);

        switch (columnIndex) {
            case 0:
                return conta.isQuitada();
            case 1:
                return conta.getId();
            case 2:
                return conta.getDescricao();
            case 3:
                return conta.getData().getTime();
            case 4:
                return conta.getTipo();
            case 5:
                return conta.getCondicao();
            case 6:
                return conta.getValor();
            default:
                throw new IndexOutOfBoundsException("columnIndex out of bounds");
        }
    }

    public Conta getConta(int row) {
        if (row >= 0) {
            return linhas.get(row);
        }
        return null;
    }

    /* Retorna um valor booleano que define se a célula em questão
     * pode ser editada ou não.
     * Este método é utilizado pela JTable na hora de definir o editor da célula.
     * Neste caso, estará sempre retornando false, não permitindo que nenhuma
     * célula seja editada. */
    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return false;
    }

    /* Adiciona um registro. */
    public void addConta(Conta c) {
        // Adiciona o registro.
        linhas.add(c);

        // Pega a quantidade de registros e subtrai um para achar
        // o último índice. É preciso subtrair um, pois os índices
        // começam pelo zero.
        int ultimoIndice = getRowCount() - 1;

        // Reporta a mudança. O JTable recebe a notificação
        // e se redesenha permitindo que visualizemos a atualização.
        fireTableRowsInserted(ultimoIndice, ultimoIndice);
    }

    /* Remove a linha especificada. */
    public void excluiConta(int indiceLinha) {
        // Remove o sócio da linha especificada.
        linhas.remove(indiceLinha);

        // Reporta a mudança. O JTable recebe a notificação
        // e se redesenha permitindo que visualizemos a atualização.
        fireTableRowsDeleted(indiceLinha, indiceLinha);
    }

    public static List<Conta> createContasList() {
        List<Conta> lista = new ArrayList<Conta>();

        Conta c1 = new Conta(1, "3ª parcela site sérgio auto peças", new Date(), 350d,
                TipoConta.ENTRADA, CondicaoConta.DINHEIRO, null, false);
        Conta c2 = new Conta(2, "pizza calabresa com catupiry", new Date(), 32d,
                TipoConta.SAIDA, CondicaoConta.DINHEIRO, null, true);
        Conta c3 = new Conta(3, "aluguel", new Date(), 600d,
                TipoConta.SAIDA, CondicaoConta.DINHEIRO, null, false);
        Conta c4 = new Conta(4, "locaweb", new Date(), 80d,
                TipoConta.SAIDA, CondicaoConta.DINHEIRO, null, false);
        Conta c5 = new Conta(5, "4ª parcela da promove", new Date(), 460d,
                TipoConta.ENTRADA, CondicaoConta.DINHEIRO, null, true);
        Conta c6 = new Conta(6, "1ª parcela dra. célia", new Date(), 250d,
                TipoConta.ENTRADA, CondicaoConta.CHEQUE, null, true);

        lista.add(c1);
        lista.add(c2);
        lista.add(c3);
        lista.add(c4);
        lista.add(c5);
        lista.add(c6);

        return lista;
    }
}
